JS设计模式之Singleton（单例）模式

定义

限制类的实例化次数只能是一次。

如果该实例不存在的情况下，可以通过一个方法创建一个类来实现创建类的新实例，如果实例已经存在，它会简单返回该对象的引用。

适用场景

1. 需要频繁实例化然后销毁的对象。
2. 频繁访问数据库或文件的对象。
3. 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。

Talk is cheap

通过打印privateRandomNumber来验证是否为同一个实例

let mySingleton = (()=> {
    let instance;

    let init = ()=> {
        let privateMethod = ()=> {//私有方法
            console.log('I am privateMethod');
        }

        let privateVariable = 'I am also private';
        let privateRandomNumber = Math.random();

        return {//共有方法和变量
            publicMethod: ()=> {
                console.log('I am public');
            },
            publicProperty: 'I am also public',
            getRandomNumber: ()=> {
                return privateRandomNumber;
            }
        }
    }

    return {//获取Singleton的实例，如果存在就返回，不存在就创建新实例
        getInstance: ()=> {
            if(!instance) {
                instance = init();
            }

            return instance;
        }
    }

})();

let singleA = mySingleton.getInstance();
let singleB = mySingleton.getInstance();

console.log(singleA.getRandomNumber() === singleB.getRandomNumber());//ture

简单封装node连接mongodb数据库

const MongoDB = require('mongodb')
const MongoClient = require('mongodb').MongoClient
const ObjectID = MongoDB.ObjectID
const Config = require('./config')

class Db {
    static getInstance() {
        if(!Db.instance) {
            Db.instance = new Db()
        }
        return Db.instance
    }
    constructor() {
        this.dbClient = ''
        this.connect()
    }
    connect() {//连接数据库
        let that = this

        return new Promise((resolve, reject)=> {
            if(!that.dbClient) {
                MongoClient.connect(Config.dbUrl, {useNewUrlParser:true}, (err, client)=> {
                    if(err) {
                        reject(err)
                    }else {
                        that.dbClient = client.db(Config.dbName)
                        resolve(that.dbClient)
                    }
                })
            }else {
                resolve(that.dbClient)
            }
        })
    }
    find(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                let result = db.collection(collectionName).find(json)

                result.toArray((err, docs)=> {
                    if(err) {
                        reject(err)
                        return
                    }
                    resolve(docs)
                })
            })
        })
    }
    update(collectionName, json1, json2) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).updateOne(json1, {
                    $set: json2
                },(err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    insert(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).insertOne(json, (err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    remove(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).removeOne(json, (err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    getObjectId(id) {
        return new ObjectID(id)
    }
}

module.exports = Db.getInstance()

参考

《Javascript设计模式》

JS设计模式系列文章

JS设计模式之Obeserver（观察者）模式、Publish/Subscribe（发布/订阅）模式
JS设计模式之Factory（工厂）模式
JS设计模式之Singleton（单例）模式
JS设计模式之Facade（外观）模式
JS设计模式之Module（模块）模式、Revealing Module（揭示模块）模式